package service

import (
	"context"
	"encoding/json"
	"fmt"

	"Data-API-MCP/backend/internal/domain/entity"
	"Data-API-MCP/backend/internal/domain/repository"
)

// SQLMessageProcessor SQL消息处理器
type SQLMessageProcessor struct {
	dbService repository.DBConnection
}

// NewSQLMessageProcessor 创建SQL消息处理器实例
func NewSQLMessageProcessor(dbService repository.DBConnection) *SQLMessageProcessor {
	return &SQLMessageProcessor{
		dbService: dbService,
	}
}

// ProcessMessage 处理SQL消息
func (p *SQLMessageProcessor) ProcessMessage(ctx context.Context, message *entity.MCPMessage, mcpContext *entity.MCPContext, model *entity.MCPModel) error {
	// 1. 解析SQL配置
	var sqlConfig SQLConfig
	if err := json.Unmarshal(model.Config, &sqlConfig); err != nil {
		return fmt.Errorf("解析SQL配置失败: %w", err)
	}

	// 2. 解析消息参数
	var params map[string]interface{}
	if err := json.Unmarshal(message.Payload, &params); err != nil {
		return fmt.Errorf("解析消息参数失败: %w", err)
	}

	// 3. 验证参数
	if err := p.validateParameters(sqlConfig.Parameters, params); err != nil {
		return fmt.Errorf("参数验证失败: %w", err)
	}

	// 4. 构建SQL语句
	sql, args, err := p.buildSQL(sqlConfig.SQL, params)
	if err != nil {
		return fmt.Errorf("构建SQL失败: %w", err)
	}

	// 5. 执行SQL
	result, err := p.dbService.Execute(ctx, sql, args...)
	if err != nil {
		return fmt.Errorf("执行SQL失败: %w", err)
	}

	// 6. 处理结果
	response, err := p.processResult(result, sqlConfig.ResponseMapping)
	if err != nil {
		return fmt.Errorf("处理结果失败: %w", err)
	}

	// 7. 更新消息负载
	responseJSON, err := json.Marshal(response)
	if err != nil {
		return fmt.Errorf("序列化响应失败: %w", err)
	}
	message.Payload = responseJSON

	return nil
}

// SQLConfig SQL配置
type SQLConfig struct {
	SQL             string                 `json:"sql"`              // SQL模板
	Parameters      []SQLParameter         `json:"parameters"`       // 参数定义
	ResponseMapping map[string]string      `json:"response_mapping"` // 响应映射
	Options         map[string]interface{} `json:"options"`          // 其他选项
}

// SQLParameter SQL参数定义
type SQLParameter struct {
	Name        string      `json:"name"`        // 参数名
	Type        string      `json:"type"`        // 参数类型
	Required    bool        `json:"required"`    // 是否必需
	Default     interface{} `json:"default"`     // 默认值
	Validation  string      `json:"validation"`  // 验证规则
	Description string      `json:"description"` // 参数描述
}

// validateParameters 验证参数
func (p *SQLMessageProcessor) validateParameters(paramDefs []SQLParameter, params map[string]interface{}) error {
	for _, def := range paramDefs {
		value, exists := params[def.Name]
		if !exists {
			if def.Required {
				return fmt.Errorf("缺少必需参数: %s", def.Name)
			}
			// 使用默认值
			params[def.Name] = def.Default
			continue
		}

		// 验证参数类型
		if err := p.validateParameterType(value, def.Type); err != nil {
			return fmt.Errorf("参数 %s 类型验证失败: %w", def.Name, err)
		}

		// TODO: 实现更多验证规则
	}
	return nil
}

// validateParameterType 验证参数类型
func (p *SQLMessageProcessor) validateParameterType(value interface{}, expectedType string) error {
	switch expectedType {
	case "string":
		if _, ok := value.(string); !ok {
			return fmt.Errorf("期望string类型")
		}
	case "number":
		switch value.(type) {
		case int, int32, int64, float32, float64:
			// 有效的数字类型
		default:
			return fmt.Errorf("期望number类型")
		}
	case "boolean":
		if _, ok := value.(bool); !ok {
			return fmt.Errorf("期望boolean类型")
		}
	case "array":
		if _, ok := value.([]interface{}); !ok {
			return fmt.Errorf("期望array类型")
		}
	case "object":
		if _, ok := value.(map[string]interface{}); !ok {
			return fmt.Errorf("期望object类型")
		}
	default:
		return fmt.Errorf("不支持的参数类型: %s", expectedType)
	}
	return nil
}

// buildSQL 构建SQL语句
func (p *SQLMessageProcessor) buildSQL(template string, params map[string]interface{}) (string, []interface{}, error) {
	// TODO: 实现SQL模板解析和参数绑定
	// 这里需要实现一个安全的SQL模板引擎，避免SQL注入风险
	return template, nil, nil
}

// processResult 处理SQL执行结果
func (p *SQLMessageProcessor) processResult(result interface{}, mapping map[string]string) (map[string]interface{}, error) {
	// TODO: 实现结果映射处理
	// 根据mapping配置将SQL结果转换为期望的响应格式
	return nil, nil
}
